package com.xique.park.service.biz.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.xique.common.core.constant.HttpStatus;
import com.xique.common.core.utils.SecurityUtils;
import com.xique.common.core.web.domain.AjaxResult;
import com.xique.park.bean.domain.ParkCarMngtype;
import com.xique.park.bean.domain.ParkCarMngtypeLane;
import com.xique.park.bean.domain.ParkLane;
import com.xique.park.bean.request.web.passAuth.PassAuthDownRequest;
import com.xique.park.bean.request.web.passAuth.PassAuthListRequest;
import com.xique.park.bean.request.web.passAuth.PassAuthSaveRequest;
import com.xique.park.bean.transform.web.passAuth.PassAuthTransform;
import com.xique.park.bean.vo.web.passAuth.PassAuthVo;
import com.xique.park.constant.DictConstant;
import com.xique.park.service.biz.service.IParkCarPassAuthBizService;
import com.xique.park.service.command.service.IParkCarMngTypeCommandService;
import com.xique.park.service.service.IParkCarMngtypeLaneService;
import com.xique.park.service.service.IParkCarMngtypeService;
import com.xique.park.service.service.IParkLaneService;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 车辆管理类型通道通行权限BizService
 *
 * @author: xique
 */
@Service
public class ParkCarPassAuthBizServiceImpl implements IParkCarPassAuthBizService {

    @Autowired
    private IParkLaneService parkLaneService;

    @Autowired
    private IParkCarMngtypeLaneService parkCarMngtypeLaneService;

    @Autowired
    private IParkCarMngTypeCommandService parkCarMngTypeCommandService;

    @Autowired
    private IParkCarMngtypeService parkCarMngtypeService;

    /**
     * 查询车辆管理类型通行权限列表
     * 1、查询车场的所有通道列表；
     * 2、查询该管理类型的所有通道通行权限列表
     * 3、遍历通道列表，如果该通道通行权限存在，则直接展示；如果没有则新建一条
     */
    @Override
    public AjaxResult getPassAuthList(PassAuthListRequest request) {
        Map<String, Object> map = new HashMap<>(1);
        ParkLane parkLane = new ParkLane();
        Long parkId = SecurityUtils.getParkId();
        parkLane.setParkId(parkId);
        List<ParkLane> parkLaneList = parkLaneService.selectParkLaneList(parkLane);
        ParkCarMngtypeLane parkCarMngtypeLane = new ParkCarMngtypeLane();
        parkCarMngtypeLane.setParkId(parkId);
        parkCarMngtypeLane.setCarMngtypeId(request.getMngTypeId());
        List<ParkCarMngtypeLane> parkCarMngtypeLaneList = parkCarMngtypeLaneService.selectParkCarMngtypeLaneList(parkId, parkCarMngtypeLane);
        List<PassAuthVo> passAuthVoList = new ArrayList<>();
        // 1、判断通道和通行权限列表长度是否一致，一致则直接返回通行权限列表
        if (CollectionUtils.isNotEmpty(parkCarMngtypeLaneList) && CollectionUtils.isNotEmpty(parkLaneList) && parkCarMngtypeLaneList.size() == parkLaneList.size()) {
            passAuthVoList = parkCarMngtypeLaneList.stream().map(PassAuthTransform::mngTypeLaneTransformVo).collect(Collectors.toList());
        } else {
            Map<String, Object> lanePassAuthMap = new HashMap<>(parkCarMngtypeLaneList.size());
            if (CollectionUtils.isNotEmpty(parkCarMngtypeLaneList)) {
                for (ParkCarMngtypeLane parkCarMngtypeLane1 : parkCarMngtypeLaneList) {
                    lanePassAuthMap.put(parkCarMngtypeLane1.getLaneId(), parkCarMngtypeLane1);
                }
            }
            if (CollectionUtils.isNotEmpty(parkLaneList)) {
                for (ParkLane parkLane1 : parkLaneList) {
                    PassAuthVo passAuthVo;
                    if (lanePassAuthMap.containsKey(String.valueOf(parkLane1.getId()))) {
                        ParkCarMngtypeLane parkCarMngtypeLane1 = (ParkCarMngtypeLane) lanePassAuthMap.get(String.valueOf(parkLane1.getId()));
                        passAuthVo = PassAuthTransform.mngTypeLaneTransformVo(parkCarMngtypeLane1);
                    } else {
                        passAuthVo = PassAuthTransform.generateDefaultMngTypeLane(parkLane1.getId());
                    }
                    passAuthVoList.add(passAuthVo);
                }
            }
        }
        // 记录同步状态处理
        for (PassAuthVo vo : passAuthVoList) {
            if (null != vo.getId()) {
                Long laneId = vo.getLaneId();
                JSONObject commandStatusObj = parkCarMngTypeCommandService.getPassAuthCommandStatus(laneId, vo.getId());
                vo.setCommandStatus(commandStatusObj.get(vo.getId()));
            }
        }
        map.put("list", passAuthVoList);
        return AjaxResult.success(map);
    }

    /**
     * 保存通道通行权限列表
     */
    @Override
    public AjaxResult savePassAuthList(PassAuthSaveRequest request) {
        Long mngTypeId = request.getMngTypeId();
        List<PassAuthVo> passAuthVoList = request.getList();
        if (CollectionUtils.isNotEmpty(passAuthVoList)) {
            List<ParkCarMngtypeLane> addParkCarMngTypeLaneList = new ArrayList<>();
            List<ParkCarMngtypeLane> updateParkCarMngtypeLaneList = new ArrayList<>();
            for (PassAuthVo vo : passAuthVoList) {
                ParkCarMngtypeLane mngtypeLane = PassAuthTransform.voTransformMngTypeLane(vo, mngTypeId);
                if (null != vo.getId()) {
                    updateParkCarMngtypeLaneList.add(mngtypeLane);
                } else {
                    addParkCarMngTypeLaneList.add(mngtypeLane);
                }
            }
            // 批量插入或者更新
            boolean addFlag = false;
            int updateCount = 0;
            if (CollectionUtils.isNotEmpty(addParkCarMngTypeLaneList)) {
                addFlag = parkCarMngtypeLaneService.saveBatch(addParkCarMngTypeLaneList);
            }
            if (CollectionUtils.isNotEmpty(updateParkCarMngtypeLaneList)) {
                updateCount = parkCarMngtypeLaneService.batchUpdate(updateParkCarMngtypeLaneList);
            }
            if (addFlag || updateCount > 0) {
                List<ParkCarMngtypeLane> allList = new ArrayList<>();
                allList.addAll(addParkCarMngTypeLaneList);
                allList.addAll(updateParkCarMngtypeLaneList);
                return parkCarMngTypeCommandService.downMngTypePassAuth(SecurityUtils.getParkId(), allList, "保存成功！");
            } else {
                return AjaxResult.error("保存失败");
            }
        } else {
            return AjaxResult.error("通行权限列表为空，无需保存");
        }
    }

    /**
     * 下载通行权限
     */
    @Override
    public AjaxResult downPassAuthList(PassAuthDownRequest request) {
        long parkId = SecurityUtils.getParkId();
        List<ParkCarMngtypeLane> parkCarMngtypeLaneList = new ArrayList<>();
        String noSetUpAuthorityMngTypeNames = null;

        // 下载全部
        if (DictConstant.YES.equals(request.getIsAll())) {
            ParkCarMngtypeLane search = new ParkCarMngtypeLane();
            search.setParkId(parkId);
            parkCarMngtypeLaneList = parkCarMngtypeLaneService.selectParkCarMngtypeLaneList(parkId, search);

            // 判断是否有未设置通行权限的车辆管理类型 BY WLD 2022-04-21
            noSetUpAuthorityMngTypeNames = noSetUpAuthorityMngType(parkId, parkCarMngtypeLaneList);
        } else {
            // 下载部分
            Long[] ids = request.getIds();
            if (ids.length > 0) {
                parkCarMngtypeLaneList = parkCarMngtypeLaneService.selectBatchcarMngtypeIds(Arrays.asList(ids));
            }
        }

        if (CollectionUtils.isNotEmpty(parkCarMngtypeLaneList)) {
            // 下发
            AjaxResult downResult = parkCarMngTypeCommandService.downMngTypePassAuth(parkId, parkCarMngtypeLaneList, "");
            // 是否下发成功
            if (downResult.get(AjaxResult.CODE_TAG).equals(HttpStatus.COMMAND_ERROR)) {
                return downResult;
            }
            if (StrUtil.isNotBlank(noSetUpAuthorityMngTypeNames)) {
                // 未设置通行权限的管理类型，也就是没下发的管理类型
                return AjaxResult.success(noSetUpAuthorityMngTypeNames + "通行权限未设置，无需下发，其他类型下发通行权限成功");
            }
            return downResult;
        } else {
            return AjaxResult.success("通行权限未设置，无需下发");
        }

    }

    /**
     * 判断是否有未设置通行权限的车辆管理类型
     *
     * @param parkCarMngtypeLaneList 已经置通行权限的车辆管理类型
     * @return 未设置通行权限的车辆管理类型
     * @author: WLD
     * @Date: 2022-04-21
     */
    private String noSetUpAuthorityMngType(long parkId, List<ParkCarMngtypeLane> parkCarMngtypeLaneList) {
        StringBuilder noSetUpAuthorityMngTypeNames = new StringBuilder();
        if (CollUtil.isNotEmpty(parkCarMngtypeLaneList)) {
            List<ParkCarMngtype> parkCarMngTypeList = parkCarMngtypeService.selectParkCarMngTypeByParkId(parkId);
            // 已经设置了通行权限的管理类型ID
            Set<Long> setUpAuthorityMngTypeIdSet = parkCarMngtypeLaneList.stream().map(ParkCarMngtypeLane::getCarMngtypeId).collect(Collectors.toSet());
            // 未设置通行权限的管理类型ID
            Set<Long> noSetUpAuthorityMngTypeIdSet = parkCarMngTypeList.stream().map(ParkCarMngtype::getId).collect(Collectors.toSet());
            noSetUpAuthorityMngTypeIdSet.removeAll(setUpAuthorityMngTypeIdSet);

            if (CollUtil.isNotEmpty(noSetUpAuthorityMngTypeIdSet)) {
                Map<Long, String> parkCarMngTypeNameMap = new HashMap<>(parkCarMngTypeList.size());
                parkCarMngTypeList.forEach(parkCarMngType -> parkCarMngTypeNameMap.put(parkCarMngType.getId(), parkCarMngType.getName()));
                // 未设置通行权限的管理类型名称
                noSetUpAuthorityMngTypeIdSet.forEach(mngTypeId -> noSetUpAuthorityMngTypeNames.append(parkCarMngTypeNameMap.get(mngTypeId)).append("，"));
            }
        }
        return noSetUpAuthorityMngTypeNames.toString();
    }

}
